/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
// class Solution {
// public:
//     void inorder(TreeNode* root, vector<int>& data)
//     {
//         if (root == nullptr)
//             return;
        
//         inorder(root->left, data);
//         data.push_back(root->val);
//         inorder(root->right, data);
//     }
//     bool isValidBST(TreeNode* root) {
//         vector<int> data;
//         inorder(root, data);

//         bool ret = true;
//         for (int i = 0; i < data.size(); i++)
//         {
//             if (i != 0 && data[i] <= data[i - 1])
//             {
//                 ret = false;
//                 break;
//             }
//         }

//         return ret;
//     }
// };

class Solution {
public:
    bool inorder(TreeNode* root, long long& preVal)
    {
        if (root == nullptr)
            return true;
        
        bool isLeft = inorder(root->left, preVal);
        if (isLeft == false)    //剪枝
            return false;

        bool isRoot = root->val > preVal;
        if (isRoot == false)    //剪枝
            return false;

        preVal = root->val;

        bool isRight = inorder(root->right, preVal);

        return isLeft && isRight && isRoot;
    }
    bool isValidBST(TreeNode* root) {
        long long preVal = (long long)INT_MIN - 1;
        return inorder(root, preVal);
    }
};